{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using saved models\n",
    "\n",
    "In this notebook, we will show how to use saved deep learning models. In deep learning it is a common practice to make trained models available so that others can reproduce the result as obtained by the person who trained it. Here, we will show results for LSTM model for FD001 of CMAPSS dataset. But the procedure is identical for other other models. While using a saved model, we have to keep two things in mind:\n",
    "\n",
    "* Use appropriate saved model (i.e., check the model name carefully while loading)\n",
    "* Use the same preprocessing steps on test data as those used while training the model.\n",
    "\n",
    "As we are going to show results for LSTM model, we will use the same preprocessing steps and other parameters (such as, early_rul, window_length, shift, etc) as those used in the training notebook of LSTM model for FD001 dataset of CMAPSS. Similar procedure can be followed for other datasets by making minor modifications to this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.metrics import mean_squared_error\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_targets(data_length, early_rul = None):\n",
    "    \"\"\" \n",
    "    Takes datalength and earlyrul as input and \n",
    "    creates target rul.\n",
    "    \"\"\"\n",
    "    if early_rul == None:\n",
    "        return np.arange(data_length-1, -1, -1)\n",
    "    else:\n",
    "        early_rul_duration = data_length - early_rul\n",
    "        if early_rul_duration <= 0:\n",
    "            return np.arange(data_length-1, -1, -1)\n",
    "        else:\n",
    "            return np.append(early_rul*np.ones(shape = (early_rul_duration,)), np.arange(early_rul-1, -1, -1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_input_data_with_targets(input_data, target_data = None, window_length = 1, shift = 1):\n",
    "    \"\"\"Depending on values of window_length and shift, this function generates batchs of data and targets \n",
    "    from input_data and target_data.\n",
    "    \n",
    "    Number of batches = np.floor((len(input_data) - window_length)/shift) + 1\n",
    "    \n",
    "    **We don't check input dimensions uisng exception handling. So readers should be careful while using these\n",
    "    functions. If input data are not of desired dimension, either error occurs or something undesirable is \n",
    "    produced as output.**\n",
    "    \n",
    "    Arguments:\n",
    "        input_data: input data to function (Must be 2 dimensional)\n",
    "        target_data: input rul values (Must be 1D array)s\n",
    "        window_length: window length of data\n",
    "        shift: Distance by which the window moves for next batch. This is closely related to overlap\n",
    "               between data. For example, if window length is 30 and shift is 1, there is an overlap of \n",
    "               29 data points between two consecutive batches.\n",
    "        \n",
    "    \"\"\"\n",
    "    num_batches = np.int(np.floor((len(input_data) - window_length)/shift)) + 1\n",
    "    num_features = input_data.shape[1]\n",
    "    output_data = np.repeat(np.nan, repeats = num_batches * window_length * num_features).reshape(num_batches, window_length,\n",
    "                                                                                                  num_features)\n",
    "    if target_data is None:\n",
    "        for batch in range(num_batches):\n",
    "            output_data[batch,:,:] = input_data[(0+shift*batch):(0+shift*batch+window_length),:]\n",
    "        return output_data\n",
    "    else:\n",
    "        output_targets = np.repeat(np.nan, repeats = num_batches)\n",
    "        for batch in range(num_batches):\n",
    "            output_data[batch,:,:] = input_data[(0+shift*batch):(0+shift*batch+window_length),:]\n",
    "            output_targets[batch] = target_data[(shift*batch + (window_length-1))]\n",
    "        return output_data, output_targets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_test_data(test_data_for_an_engine, window_length, shift, num_test_windows = 1):\n",
    "    \"\"\" This function takes test data for an engine as first input. The next two inputs\n",
    "    window_length and shift are same as other functins. \n",
    "    \n",
    "    Finally it takes num_test_windows as the last input. num_test_windows sets how many examplles we\n",
    "    want from test data (from last). By default it extracts only the last example.\n",
    "    \n",
    "    The function return last examples and number of last examples (a scaler) as output. \n",
    "    We need the second output later. If we are extracting more than 1 last examples, we have to \n",
    "    average their prediction results. The second scaler halps us do just that.\n",
    "    \"\"\"\n",
    "    max_num_test_batches = np.int(np.floor((len(test_data_for_an_engine) - window_length)/shift)) + 1\n",
    "    if max_num_test_batches < num_test_windows:\n",
    "        required_len = (max_num_test_batches -1)* shift + window_length\n",
    "        batched_test_data_for_an_engine = process_input_data_with_targets(test_data_for_an_engine[-required_len:, :],\n",
    "                                                                          target_data = None,\n",
    "                                                                          window_length = window_length, shift = shift)\n",
    "        return batched_test_data_for_an_engine, max_num_test_batches\n",
    "    else:\n",
    "        required_len = (num_test_windows - 1) * shift + window_length\n",
    "        batched_test_data_for_an_engine = process_input_data_with_targets(test_data_for_an_engine[-required_len:, :],\n",
    "                                                                          target_data = None,\n",
    "                                                                          window_length = window_length, shift = shift)\n",
    "        return batched_test_data_for_an_engine, num_test_windows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to perform same preprocessing steps as those done while training the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processed test data shape:  (497, 30, 14)\n",
      "True RUL shape:  (100,)\n"
     ]
    }
   ],
   "source": [
    "train_data = pd.read_csv(\"/home/biswajit/data/cmapss_data/train_FD001.txt\", sep = \"\\s+\", header = None)\n",
    "test_data = pd.read_csv(\"/home/biswajit/data/cmapss_data/test_FD001.txt\", sep = \"\\s+\", header = None)\n",
    "true_rul = pd.read_csv('/home/biswajit/data/cmapss_data/RUL_FD001.txt', sep = '\\s+', header = None)\n",
    "\n",
    "window_length = 30\n",
    "shift = 1\n",
    "early_rul = 125            \n",
    "processed_train_data = []\n",
    "processed_train_targets = []\n",
    "\n",
    "# How many test windows to take for each engine. If set to 1 (this is the default), only last window of test data for \n",
    "# each engine are taken. If set to a different number, that many windows from last are taken. \n",
    "# Final output is the average of output of all windows.\n",
    "num_test_windows = 5     \n",
    "processed_test_data = []\n",
    "num_test_windows_list = []\n",
    "\n",
    "columns_to_be_dropped = [0,1,2,3,4,5,9,10,14,20,22,23]\n",
    "\n",
    "# Scale data for all engines\n",
    "train_data_first_column = train_data[0]\n",
    "test_data_first_column = test_data[0]\n",
    "scaler = StandardScaler()\n",
    "scaler.fit(train_data.drop(columns = columns_to_be_dropped))\n",
    "test_data = scaler.transform(test_data.drop(columns = columns_to_be_dropped))\n",
    "test_data = pd.DataFrame(data = np.c_[test_data_first_column, test_data])\n",
    "\n",
    "num_test_machines = len(test_data[0].unique())\n",
    "\n",
    "for i in np.arange(1, num_test_machines + 1):\n",
    "    \n",
    "    # We want to show our result on test set. So we don't need to keep training data.\n",
    "    temp_test_data = test_data[test_data[0] == i].drop(columns = [0]).values\n",
    "    \n",
    "    # Verify if data of given window length can be extracted from test data\n",
    "    if (len(temp_test_data) < window_length):\n",
    "        print(\"Test engine {} doesn't have enough data for window_length of {}\".format(i, window_length))\n",
    "        raise AssertionError(\"Window length is larger than number of data points for some engines. \"\n",
    "                             \"Try decreasing window length.\")\n",
    "\n",
    "    # Prepare test data\n",
    "    test_data_for_an_engine, num_windows = process_test_data(temp_test_data, window_length = window_length, shift = shift,\n",
    "                                                             num_test_windows = num_test_windows)\n",
    "    \n",
    "    processed_test_data.append(test_data_for_an_engine)\n",
    "    num_test_windows_list.append(num_windows)\n",
    "\n",
    "processed_test_data = np.concatenate(processed_test_data)\n",
    "true_rul = true_rul[0].values\n",
    "\n",
    "print(\"Processed test data shape: \", processed_test_data.shape)\n",
    "print(\"True RUL shape: \", true_rul.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load the model\n",
    "\n",
    "First download the model from [here](https://github.com/biswajitsahoo1111/rul_codes_open/blob/master/saved_models/cmapss/FD001_LSTM_piecewise_RMSE_15.1582.h5). Then change the following line to point to the folder where the downloaded model is saved. To see results for other models, first download that model and then apply the same preprocessing steps as those in the notebook. All saved models for Turbofan dataset can be found [here](https://github.com/biswajitsahoo1111/rul_codes_open/tree/master/saved_models/cmapss)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "lstm (LSTM)                  (None, 30, 128)           73216     \n",
      "_________________________________________________________________\n",
      "lstm_1 (LSTM)                (None, 30, 64)            49408     \n",
      "_________________________________________________________________\n",
      "lstm_2 (LSTM)                (None, 32)                12416     \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 96)                3168      \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 128)               12416     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 1)                 129       \n",
      "=================================================================\n",
      "Total params: 150,753\n",
      "Trainable params: 150,753\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = tf.keras.models.load_model(\"FD001_LSTM_piecewise_RMSE_15.1655.h5\")\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE:  15.165528763384067\n"
     ]
    }
   ],
   "source": [
    "rul_pred = model.predict(processed_test_data).reshape(-1)\n",
    "preds_for_each_engine = np.split(rul_pred, np.cumsum(num_test_windows_list)[:-1])\n",
    "mean_pred_for_each_engine = [np.average(ruls_for_each_engine, weights = np.repeat(1/num_windows, num_windows)) \n",
    "                             for ruls_for_each_engine, num_windows in zip(preds_for_each_engine, num_test_windows_list)]\n",
    "RMSE = np.sqrt(mean_squared_error(true_rul, mean_pred_for_each_engine))\n",
    "print(\"RMSE: \", RMSE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "RMSE using only last example of each engine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE (Taking only last examples):  15.12529934391931\n"
     ]
    }
   ],
   "source": [
    "indices_of_last_examples = np.cumsum(num_test_windows_list) - 1\n",
    "preds_for_last_example = np.concatenate(preds_for_each_engine)[indices_of_last_examples]\n",
    "\n",
    "RMSE_new = np.sqrt(mean_squared_error(true_rul, preds_for_last_example))\n",
    "print(\"RMSE (Taking only last examples): \", RMSE_new)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For CMAPSS data, along with RMSE another metric (S-score) is usually reported in literature. S-score is defined as:\n",
    "\n",
    "$$S= \\sum_{i=1}^N{s_i}$$\n",
    "\n",
    "where, \n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "    s_i=\n",
    "    \\begin{cases}\n",
    "      (e^{-\\frac{d_i}{13}})-1, & \\text{for}\\ d_i < 1 \\\\\n",
    "      (e^{\\frac{d_i}{10}})-1, & \\text{for}\\ d_i \\geq 1\\\\\n",
    "    \\end{cases}\n",
    "  \\end{equation}\n",
    "  $$\n",
    "  \n",
    "We can compute the S-metric as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_s_score(rul_true, rul_pred):\n",
    "    \"\"\"\n",
    "    Both rul_true and rul_pred should be 1D numpy arrays.\n",
    "    \"\"\"\n",
    "    diff = rul_pred - rul_true\n",
    "    return np.sum(np.where(diff < 0, np.exp(-diff/13)-1, np.exp(diff/10)-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S-score:  448.43592916864617\n"
     ]
    }
   ],
   "source": [
    "s_score = compute_s_score(true_rul, preds_for_last_example)\n",
    "print(\"S-score: \", s_score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot true and predicted RUL values\n",
    "plt.plot(true_rul, label = \"True RUL\", color = \"red\")\n",
    "plt.plot(preds_for_last_example, label = \"Pred RUL\", color = \"blue\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe that our results match exactly with that of [LSTM notebook of FD001](https://github.com/biswajitsahoo1111/rul_codes_open/blob/master/notebooks/cmapss_notebooks/CMAPSS_FD001_LSTM_piecewise_linear_degradation_model.ipynb). To use other models, just read the appropriate model and use the same preprocessing step as was used in that notebook. \n",
    "\n",
    "For other reproducible results on RUL, interested readers can visit my [project page](https://biswajitsahoo1111.github.io/rul_codes_open)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf_cpu_23",
   "language": "python",
   "name": "tf_cpu_23"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
